#include <iostream>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <thread>
#include<sched.h>
#include<vector>
#include<sys/wait.h>
#include<sys/types.h>

int *p = nullptr;
void* threadrun(void* agrs)
{
    int a = 123;
    p = &a;
    while(true)
    {
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,threadrun,nullptr);

    while(true)
    {
        //sleep(1);
        std::cout<<"*p :"<<*p<<std::endl;
    }

    pthread_join(tid,nullptr);
    return 0;
}


// #define STACK_SIZE (1024*1024)
// //进程间通信

// static int child_func(void* args)
// {
//     while(true)
//     {
//         printf("child process: PID = %d\n",getpid());
//         sleep(1);
//     }

//     return 0;
// }

// int main()
// {
//     char* stack = (char*)malloc(STACK_SIZE);//为子进程分配栈空间

//     if(stack==nullptr)
//     {
//         perror("malloc");
//         exit(EXIT_FAILURE);
//     }

//     //使用clone创建子进程
//     pid_t pid = clone(child_func,stack+STACK_SIZE,CLONE_VM ,NULL);
//     if(pid==-1)
//     {
//         perror("clone");
//         free(stack);
//         exit(EXIT_FAILURE);
//     }

//     printf("Parent process :PID = %d, Child PId:PID = %d\n",getpid(),pid);

//     //等待子进程结束
//     if(waitpid(pid,NULL,0)==-1)
//     {
//         perror("waitpid");
//         free(stack);
//         exit(EXIT_FAILURE);
//     }

//     free(stack);
//     return 0;
// }



// //创建多线程
// const int num = 10;

// void * routine(void* args)
// {
//     sleep(1);//在这里睡眠一秒是有原因的，char id[64]在那个位置都不行
//     std::string name = static_cast<const char*>(args);
//     delete (char*)args;
    
//     int cnt = 5;
//     while(cnt--)
//     {
//         std::cout<<"新线程的名字："<<name<<std::endl;
//     }
    
//     return nullptr;
// }

// int main()
// {
//     std::vector<pthread_t> tids;
//     //char id [64];
//     for(int i = 0;i<num;i++)
//     {
//         pthread_t tid;
        
//         //char id [64];

//         char* id = new char[64];
//         snprintf(id,64,"thread-%d",i);
//         int n = pthread_create(&tid,nullptr,routine,id);
//         if(n==0)
//         {
//             tids.push_back(tid);
//         }
//         else
//         {
//             continue;
//         }

//     }

//     for(int i = 0;i<num;i++)
//     {
//         //一个个等待
//         int n = pthread_join(tids[i],nullptr);
//         if(n==0)
//         {
//             std::cout<<"等待线程成功"<<std::endl;
//         }

//     }

//     return 0;
// }


// // 给线程传递的参数和返回值，可以是任意类型
// class Task
// {
// public:
//     Task(int a, int b)
//         : _a(a), _b(b)
//     {
//     }

//     int Execute()
//     {
//         return _a + _b;
//     }

//     ~Task() {}

// private:
//     int _a;
//     int _b;
// };

// class Result
// {
// public:
//     Result(int result)
//         : _result(result)
//     {
//     }

//     int GetResult()
//     {
//         return _result;
//     }

//     ~Result() {}

// private:
//     int _result;
// };


// void *routine(void *args)
// {
//     // pthread_detach(pthread_self());
//     // std::cout<<"新线程被分离了"<<std::endl;

//     int cnt = 5;
//     while (cnt--)
//     {
//         std::cout << "新线程的名字："<< std::endl;
//         sleep(1);
//     }

//     Task* t = static_cast<Task*>(args);
//     Result *res = new Result(t->Execute());
//     sleep(1);
//     return res;
//     //pthread_exit(res);
//     std::cout<<"新线程应该看不到这里"<<std::endl;

//     //return nullptr;
// }

// int main()
// {
//     pthread_t tid;
//     Task* t = new Task(10,20);
//     pthread_create(&tid, nullptr, routine, t);
//     //pthread_create(&tid, nullptr, routine, (void*)"thread-1");

//     // pthread_detach(tid);
//     // std::cout<<"新线程被分离了"<<std::endl;

//     int cnt = 5;
//     while (cnt--)
//     {
//         std::cout << "main线程" << std::endl;
//         // sleep(1);
//     }

//     // int n = pthread_join(tid,nullptr);
//     // if(n!=0)
//     // {
//     //     std::cout<<"pthread_join error:"<<strerror(n)<<std::endl;
//     // }
//     // else
//     // {
//     //     std::cout<<"pthread_join succcess:"<<strerror(n)<<std::endl;
//     // }

//     // sleep(3);
//     // pthread_cancel(tid);
//     // pthread_join(tid,nullptr);
//     // std::cout<<"新线程取消"<<std::endl;

//     // void* ret = nullptr;
//     // pthread_join(tid,&ret);
//     // std::cout<<"新线程结束，运行结果："<<(long long)ret<<std::endl;


//     Result* ret = nullptr;
//     pthread_join(tid,(void**)&ret);
//     int n = ret->GetResult();
//     std::cout<<"新线程结束，运行结果："<< n<<std::endl;

//     delete ret;
    
//     return 0;

// }

// int flag = 100;
// void showtid(pthread_t & tid)
// {
//     printf("tid:0x%lx\n",tid);
// }

// std::string FormatId(const pthread_t & tid)
// {
//     char id[63];
//     snprintf(id,sizeof(id),"0x%lx",tid);
//     return id;
// }

// void* routine(void* argc)
// {
//     std::string name = static_cast<const char*>(argc);
//     pthread_t tid = pthread_self();
//     int cnt = 5;

//     while(cnt)
//     {
//         std::cout<<"我是一个新线程，我的名字是："<<name<<",我的ID："<<FormatId(tid)<<std::endl;
//         sleep(1);
//         cnt--;
//         flag++;
//     }

//     return (void*)123;//可以暂时表示进程退出时的退出码
// }

// int main()
// {
//     pthread_t tid;
//     int n = pthread_create(&tid,nullptr,routine,(void*)"thread-1");
//     showtid(tid);

//     int cnt = 5;
//     while(cnt)
//     {
//         std::cout<<"我是main线程，"<<"我的Id是："<<FormatId(pthread_self())<<",flag:"<<flag<<std::endl;
//         sleep(1);
//         cnt--;
//     }

//     void* ret = nullptr;
//     //为什么看不到发送信号？
//     //等待的线程如果异常了，整个进程就退出了，所有join异常没有意义，也看到
//     //join就是基于：线程是健康跑完的，不需要处理异常信号，异常信号，是进程需要处理的话题！
//     pthread_join(tid,&ret);
//     std::cout<<"ret is :"<<(long long int)ret<<std::endl;

//     return 0;
// }

// void hello ()
// {
//     sleep(5);
//     std::cout<<"我是一个新线程：hello world,pid:"<<getpid()<<std::endl;

// }
// int main()
// {
//     std::thread t(hello);

//     std::cout<<"我是主线程..."<<",pid:"<<getpid()<<std::endl;
//     sleep(1);

//     t.join();

//     return 0;

// }

// void* threadrun(void* args)
// {
//     std::string name = (const char*)args;
//     while(true)
//     {
//         sleep(1);
//         std::cout<<"我是一个新线程：name："<<name<<",pid:"<<getpid()<<std::endl;

//     }

//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,threadrun,(void*)"thread-1");

//     while(true)
//     {
//         std::cout<<"我是主线程..."<<",pid:"<<getpid()<<std::endl;
//         sleep(1);
//     }

//     return 0;
// }